﻿#include<bits/stdc++.h> 

using namespace std;
string s1,s2;
int st1[30],st2[30];
int main(){
    while (cin >>s1 >>s2){
        memset(st1,0, sizeof(st1));
        memset(st2,0, sizeof(st2));
        if (s1.length()!= s2.length()) {
            cout<<"NO"<< endl;
            continue;
        }
        for (int i=0;i < s1.length(); i++)
        st1[s1[i] -'A']++, st2[s2[i] - 'A']++;
        sort(st1,st1 + 26);
        sort(st2,st2 + 26);
        bool flag = true;
        for (int i=0; i< 26; i++){
            if (st1[i] !=st2[i]){
                cout << "NO" << endl;
                flag = false;
                break;
            }
        }
        if (flag){
            cout<<"YES" << endl;
        }
    }
    return 0;
}



class Solution {
public:
    int minimumOperations(string leaves) {
        int n = leaves.size();
        int g = (leaves[0] == 'y' ? 1 : -1);
        int gmin = g;
        int ans = INT_MAX;
        for (int i = 1; i < n; ++i) {
            int isYellow = (leaves[i] == 'y');
            g += 2 * isYellow - 1;
            if (i != n - 1) {
                ans = min(ans, gmin - g);
            }
            gmin = min(gmin, g);
        }
        return ans + (g + n) / 2;
    }
};



#define _CRT_SECURE_NO_WARNINGS 1

//#define _CRT_SECURE_NO_WARNINGS 1
//
//#include<iostream>
////
////using namespace std;
////int main()
////{
////	int m = 0123;
////	cout << m;
////	return 0;
////}
//#include <stdio.h>
////int cnt = 0;
////int fib(int n) {
////	cnt++;
////	if (n == 0)
////		return 1; 
////	else if (n == 1)
////		return 2; 
////	else
////		return fib(n - 1) + fib(n - 2);
////}
////int main() {
////	fib(8);
////	printf("%d", cnt);
////}
//
//
////char fun(char x, char y) {
////	if (x < y)
////		return x;
////	return y;
////}
//int main() {
//
//	/*char c = 'A';
//	for (int i = 1; i < 20; i++)
//		cout << "@OLE(\'D:/线性规划/first_result.xlsx\', " << char(c + i - 1) << 5 << ")=q" << i << ";"<<endl;*/
//
//
//
//	return 0;
//}
//

//
//#include <iostream>
//
//#include<windows.h >
//using namespace std;
//
//int main()
//{
//
//	fork();
//	return 0;
//}

//#include <iostream>
//using namespace std;
//int main(void)
//{
//	const int a = 10;
//	int* p = (int*)(&a); 
//	*p = 20;
//	cout << "a = " << a << " ，*p = " << *p << endl; return 0;
//}

//#include <iostream>
//#include<stack>
//#include <cassert>
//using namespace std;
//bool isplalindrome(string& s)
//{
//	stack<char> st;
//	int len = s.size();
//	for (int i = 0; i < len / 2; i++)
//	{
//		st.push(s[i]);
//	}
//	int j = len / 2;
//	if (len % 2)
//		j++;
//	for (; j < len; j++)
//	{
//		if (st.top() == s[j])
//			st.pop();
//		else
//			return false;
//	}
//	return st.empty();
//}
//
//
////构造队列
//typedef struct QueueNode {
//	struct QueueNode* next;
//	int data;
//}QNode;
//typedef struct Queue {
//	QNode* rear;
//}Queue;
//bool EmptyQueue(Queue* pq);
////置空队
//void InitQueue(Queue* pq) {
//	QNode* h;
//	//当循环队列为空时，头节点指向队尾，进行初始化
//	pq->rear->next = pq->rear;
//	//当循环队列不为空时，再进行毁队列
//	while (!EmptyQueue(pq)) {
//		h = pq->rear->next;
//		pq->rear->next = h->next;
//		free(h);
//	}
//}
////判断队列为空
//bool EmptyQueue(Queue* pq) {
//	//pq->rear->next(指向头节点)当头节点的next指针指向自己时队列为空
//	//注意：此处的队列是循环类型，和带头结点双向循环的链表进行比较（当头节点的指针指向自己时该链表为空）
//	return pq->rear->next->next == pq->rear->next;
//}
////入队
//void EnQueue(Queue* pq, int x) {
//	QNode* newnode = (QNode*)malloc(sizeof(QNode));
//	if (newnode == NULL) {
//		perror("malloc fail");
//		return;
//	}
//	//将新节点链接在尾节点之后
//	newnode->next = pq->rear->next;
//	newnode->data = x;
//	//更新尾节点
//	pq->rear = pq->rear->next;
//}
////出队并返回队头元素
//int DeQueue(Queue* pq) {
//	//将头节点之后的元素取掉
//	QNode* tmp = pq->rear->next->next;
//	//保存队头元素的数据
//	int x = tmp->data;
//	//情况一：队列之中只有一个节点
//	if (tmp == pq->rear) {
//		pq->rear = pq->rear->next;
//		pq->rear->next = tmp->next;
//	}
//	else {
//		pq->rear->next->next = tmp->next;
//	}
//	free(tmp);
//	return x;
//}
//
//#define Datatype int
//typedef struct node
//{ // 定义循环链表 
//	Datatype data;
//	struct node* next;
//} LinkNode;
//
//void CreateL(LinkNode* L, Datatype data[], int n)
//{ // 头插法创建 
//	LinkNode* s;
//	int i;
//	L->next = NULL;
//	for (i = 0; i < n; i++)
//	{
//		s = (LinkNode*)malloc(sizeof(LinkNode));
//		s->data = data[i];
//		s->next = L->next;
//		L->next = s;
//	}
//	return;
//}
//
//void SetEmptyL(LinkNode* L)
//{ // 置空 
//	L->next = NULL;
//
//	return;
//}
//
//int LengthL(LinkNode* L)
//{ // 返回长度 
//	LinkNode* p = L;
//	int len = 0;
//	while (p->next != NULL)
//	{
//		len++;
//		p = p->next;
//	}
//
//	return len;
//}
//
//int IsEmptyL(LinkNode* L)
//{ // 判断队空 
//	return !LengthL(L);
//}
//
//void EnqueueL(LinkNode* L, Datatype data)
//{ // 入队 
//	LinkNode* s;
//	s = (LinkNode*)malloc(sizeof(LinkNode));
//	s->data = data; // s节点插在头节点L之后 
//	s->next = L->next;
//	L->next = s;
//	return;
//}
//
//LinkNode* DequeueL(LinkNode* L)
//{ // 出队
//	if (IsEmptyL(L))
//	{ // 为空返回NULL 
//		printf("Empty!");
//		return NULL;
//	}
//	LinkNode* s = L;
//	LinkNode* p;
//	while (s->next->next != NULL)
//		s = s->next; // 遍历至最后一个节点的前一个节点 
//	p = s->next;
//	s->next = NULL;
//
//	return p;
//}

//int main()
//{
//	LinkNode* L = (LinkNode*)malloc(sizeof(LinkNode));
//	LinkNode* p;
//	char ch[5] = { 'a', 'a', 'a', 'a', 'a' };
//	CreateL(L, ch, 5);
//	printf("%d\n", IsEmptyL(L));
//	SetEmptyL(L);
//	printf("%d\n", IsEmptyL(L));
//	EnqueueL(L, 'a');
//	printf("%d\n", IsEmptyL(L));
//	EnqueueL(L, 'b');
//	EnqueueL(L, 'c');
//	EnqueueL(L, 'd');
//	EnqueueL(L, 'e');
//	while (p = DequeueL(L))
//		printf("%c\n", p->data);
//	printf("\n%d\n", IsEmptyL(L));
//
//
//	return 0;
//}


//
//int main(void)
//{
//	string s;
//	cin >> s;
//	cout<<isplalindrome(s);
//	return 0;
//}


//
//
////构造队列
//typedef struct QueueNode {
//	struct QueueNode* next;
//	int data;
//}QNode;
//typedef struct Queue {
//	QNode* rear;
//}Queue;
//
////队列初始化
//void InitQueue(Queue* pq) {
//	QNode* head = (QNode*)malloc(sizeof(QNode));
//	if (head == nullptr)
//		perror("初始化失败！\n");
//	head->next = head;
//	pq->rear = head;
//}
////队列置空
//void DestroyQueue(Queue* pq)
//{
//	assert(pq);
//	if (EmptyQueue(pq))
//		return;
//	QNode* head=pq->rear->next;
//	//不断出队头元素直到空
//	while (!EmptyQueue(pq)) {
//		DeQueue(pq);
//	}
//}
////判断队列为空
//bool EmptyQueue(Queue* pq) {
//	//pq->rear->next(为头节点) 头结点自己指向自己对列为空
//	return pq->rear->next == pq->rear;
//}
////入队
//void EnQueue(Queue* pq, int x) {
//	QNode* newnode = (QNode*)malloc(sizeof(QNode));
//	if (newnode == NULL) {
//		perror("入队失败！\n");
//		return;
//	}
//	newnode->data = x;
//	//将新节点入队
//	newnode->next = pq->rear->next;
//	pq->rear->next = newnode;
//	//更新尾节点
//	pq->rear = newnode;
//}
////出队并返回队头元素
//int DeQueue(Queue* pq) {
//	assert(pq&&!EmptyQueue(pq));
//	//将头节点之后的元素取掉
//	QNode* head = pq->rear->next;
//	QNode* tmp = pq->rear->next->next;
//	int res = tmp->data;
//	head->next = tmp->next;
//	free(tmp);
//	return res;
//}

#include<iostream>
using namespace std;
//int getLCA(int a, int b) {
//	// write code here
//	//1
//	//2 3
//	//45 67
//	int max = a > b ? a : b;
//	int min = a < b ? a : b;
//	while (max >= 2 * min)
//	{
//		max = max / 2;
//	}
//	cout<<min<<" "<<max<<endl;
//	while (max != min)
//	{
//		max = max / 2, min = min / 2;
//	}
//	return max;
//}
//int main()
//{
//	cout << getLCA(57530, 209947);
//	return 0;
//}

//
//class A {
//public:
//	virtual void print(){
//		cout << "A: :print()" << "\n";
//}
//};
//class B : public A {
//public: virtual void print()
//{
//	cout << "B : : print()" << "\n";
//
//}
//
//
//};
//class c : public A {
//public: virtual void print() {
//cout << "C : :print()" << "\n";
//}
//	
//};
//void print(A a){
//a.print(); }
//int main() {
//	A a, * aa, * ab, * ac; B b;
//	c c;
//	aa = &a; ab = &b; ac = &c;
//	a.print(); b.print(); c.print();
//	aa->print(); ab->print(); ac->print();
//	print(a); print(b); print(c);
//}



#include <iostream>
using namespace std;
//class parent {
//	int i;
//protected:
//	int x;
//public:
//	parent() { x = 0; i = 0; }
//	void change() {
//		x++; i++;}
//	void display();
//};
//	
//void parent::display() {
//	cout << "x=" << x << endl;
//}
//class son :public parent {
//public:
//	void modify();
//};
//
//void son::modify() {
//	x++;
//}
//
//
//int main() {
//	son A;
//	parent B;
//	A.display();
//	A.change();
//	A.modify();
//	A.display();
//	B.change();
//	B.display();
//	return 0;
//}



//class A {
//public:
//	void test(float a) { cout << "1"; }
//};
//class B :public A {
//	void test(int b) { cout << "2"; }
//};
//int main()
//{
//	A*a = new A;
//	B* b = new B; 
//	//a还是一个A指针类型
//	a = b;
//	a->test(1.1);
//}


//
//class Base {
//public:
//	Base(int j) : i(j) {}virtual~Base() {}void func1() {
//		i *= 10; func2();
//	}
//	int getValue() {
//		return i;
//	}
//protected:
//	virtual void func2() {
//		i++;
//	}
//protected:int i;
//};
//class Child : public Base {
//public:
//	Child(int j) 
//		: Base(j){}
//	void func1() {
//	i *= 100; func2();
//	}
//protected:
//	void func2() {
//		i += 2;
//	}
//
//};
//int main() {
//	Base* pb = new Child(1);
//	pb->func1();
//	cout << pb->getValue() << endl; 
//	delete pb;
//}


//class A {
//public:
//	virtual void func(int val = 1)
//	{ std :: cout << "A->" << val << std :: endl;
//}
//	virtual void test(){
//	func();}
//};
//class B : public A {
//public:
//	void func(int val = 0) { std:: cout << "B->" << val << std :: endl; }
//};
//int main(int argc, char* argv[]) {
//	B* p = new B; p->test(); return 0;
//}


//class A {
//public:
//	void foo() {
//		printf("1");
//	}
//	virtual void fun() {
//		printf("2");
//	}
//};
//class B : public A {
//public:
//	void foo() {
//		printf("3");
//	}
//	void fun() {
//		printf("4");
//	}
//};
//int main(void){
//	A a; B b;
//	A* p = &a; 
//	p->foo(); p->fun(); 
//	p = &b; p->foo(); p->fun();
//	A* ptr = (A*)&b; 
//	ptr->foo();
//	ptr->fun(); 
//	return 0;
//}

//class A{
//public:
//	A(){
//		printf("A");
//}
//	~A(){
//	printf("deA");
//	}
//};
//class B{
//public:
//	B() {
//		printf("B");
//	}
//	~B() {
//		printf("deB");
//	}
//
//};
//class c : public A, public B {
//public:
//	c() {
//		printf("C ");
//	}
//	~c() {
//		printf("dec");
//	}
//};
//int main() {
//	A* a = new c(); delete a;
//	return 0;
//}

//#include<map>
//
//int main()
//{
//	map<int, int> m;
//	cout << m[1] << endl;
//	cout << m.size() << endl;
//	return 0;
//}

//
//
//class Test {
//public:
//	int a; int b;
//	virtual void fun() {}
//	Test(int temp1 = 0, int temp2 = 0) {
//		a = temp1; b = temp2;
//	}
//	int getA() {
//		return a;
//	}
//	int getB() {
//		return b;
//	}
//};
//int main() {
//	Test obj(5,10);
//	// changing a and b
//	int* pInt = (int*)&obj; *(pInt + 0) = 100;
//	*(pInt + 1) = 200;
//	cout << "a = " << obj.getA() << endl; 
//	cout << "b = " << obj.getB() << endl; return 0;
//
//}



//class A {
//public:
//	void print() {
//		cout << "A: print( )";
//	}
//};
//class B : private A {
//public:
//	void print() {
//		cout << "B : print( )";
//	}
//};
//class c : public B {
//public:
//	void print() {
//	A:: print();
//	}
//};

//class Base {
//public:
//	int Bar(char x) {
//		return (int)(x);
//	}
//	virtual int Bar(int x){
//		return (2 * x);
//}
//};
//class Derived : public Base {
//public:
//	int Bar(char x) {
//		return (int)(-x);
//	}
//	int Bar(int x) {
//		return (x / 2);
//	}
//};
//int main(void) {
//	Derived obj;
//	Base* pobj = &obj;
//	printf("%d, ", pobj->Bar((char)(100))); printf("%d, ", pobj->Bar(100));
//}


//class A {
//public:
//	void FuncA() {
//		printf("FuncA called\n");
//	}
//	virtual void FuncB(){
//		printf("FuncB called\n");
//	}
//};
//class B : public A{
//public:
//	void FuncA() {
//	A:: FuncA();
//		printf("FuncAB called\n");
//	}
//	virtual void FuncB() {
//		printf("FuncBB called\n");
//	}
//};
//
//void main(void) {
//	B b;
//	A* pa;
//	pa = &b;
//	A* pa2 = new A; pa->FuncA(); 
//	pa->FuncB(); 
//	pa2->FuncA(); 
//	pa2->FuncB();
//	delete pa2;
//}



 //#include<iostream>
 //using namespace std;

 //int k = 0;
 //class A
 //{
 //public:
 //    void fun(int a=k)
 //    {

 //    }
 //private:
 //    int _a;
 //};

 //int main()
 //{

 //    return 0;
 //}



#include<iostream>
 using namespace std;
 /*int main()
 {
	 string a = "hello world";

	 string b = a;

	 if (a.c_str() == b.c_str())

	 {

		 cout << "true" << endl;

	 }

	 else cout << "false" << endl;

	 string c = b;

	 c = "";

	 if (a.c_str() == b.c_str())

	 {

		 cout << "true" << endl;

	 }

	 else cout << "false" << endl;

	 a = "";

	 if (a.c_str() == b.c_str())

	 {

		 cout << "true" << endl;

	 }

	 else cout << "false" << endl;

	 return 0;
 }*/















 /*bool check(string& s1,string& s2)
 {

 }
 int main()
 {
     string s1,s2;
     cin>>s1>>s2;
     if(check(s1,s2))
         cout<<"true";
     else
         cout<<"false";
     return 0;
 }*/

//
//int main()
//{
//	string strText = "How are you?";
//	string strSeparator = " ";
//	string strResult;
//	int size_pos = 0;
//	int size_prev_pos = 0;
//
//	while ((size_pos = strText.find_first_of(strSeparator, size_pos)) != string::npos)
//
//	{
//		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
//		cout << strResult << " ";
//		size_prev_pos = ++size_pos;
//	}
//
//	if (size_prev_pos != strText.size())
//	{
//		strResult = strText.substr(size_prev_pos, size_pos - size_prev_pos);
//		cout << strResult << " ";
//	}
//	cout << endl;
//	return 0;
//
//}
#include<vector>
//int main()
//{
//	/*vector<int> arr;
//	arr.reserve(1000);
//	cout << arr.capacity() << endl;
//
//	arr.reserve(100);
//	cout << arr.capacity() << endl;*/
//
//
//	int ar[] = { 1,2,3,4,5,6,7,8,9,10 };
//
//	int n = sizeof(ar) / sizeof(int);
//
//	vector<int> v(ar, ar + n);
//
//	cout << v.size() << ":" << v.capacity() << endl;
//
//	v.reserve(100);
//
//	v.resize(20);
//
//	cout << v.size() << ":" << v.capacity() << endl;
//
//	v.reserve(50);
//
//	v.resize(5);
//
//	cout << v.size() << ":" << v.capacity() << endl;
//	return 0;
//}
//int main()
//{
//	vector<int>array;
//
//	array.push_back(100);
//
//	array.push_back(300);
//
//	array.push_back(300);
//
//	array.push_back(300);
//
//	array.push_back(300);
//
//	array.push_back(500);
//
//	vector<int>::iterator itor;
//
//	for (itor = array.begin(); itor != array.end(); itor++)
//
//	{
//
//		if (*itor == 300)
//
//		{
//
//			itor = array.erase(itor);
//
//		}
//
//	}
//
//	for (itor = array.begin(); itor != array.end(); itor++)
//
//	{
//
//		cout << *itor << " ";
//
//	}
//
//	return 0;
//}



#include <stdio.h>

int main()
{
	char buffer[50];
	const char* s = "runoobcom";

	// 读取字符串并存储在 buffer 中
	int j = snprintf(buffer, 6, "%s\n", s);

	// 输出 buffer及字符数
	printf("string:\n%s\ncharacter count = %d\n", buffer, j);

	j = snprintf(buffer, 6, "%s\n", s);

	// 输出 buffer及字符数
	printf("string:\n%s\ncharacter count = %d\n", buffer, j);

	return 0;
}